Amiga Format CD 24/Amiga Format AFCD24 (Feb 1998, Issue 108).iso/-in_the_mag-/emulation/macos/uae069b2.src.cpt.hqx/UAE069ß2.SRC.CPT/uae069fl2.src/filesys.c

C/C++ Source or Header | 1997-06-18 | 75KB | 2,710 lines

 /*
  * UAE - The Un*x Amiga Emulator
  *
  * Unix file system handler for AmigaDOS
  *
  * Copyright 1996 Ed Hanway
  * Copyright 1996, 1997 Bernd Schmidt
  *
  * Version 0.4: 970308
  *
  * Based on example code (c) 1988 The Software Distillery
  * and published in Transactor for the Amiga, Volume 2, Issues 2-5.
  * (May - August 1989)
  *
  * Known limitations:
  * Does not support ACTION_INHIBIT (big deal).
  * Does not support any 2.0+ packet types (except ACTION_SAME_LOCK)
  * Does not support removable volumes.
  * May not return the correct error code in some cases.
  * Does not check for sane values passed by AmigaDOS.  May crash the emulation
  * if passed garbage values.
  * Could do tighter checks on malloc return values.
  * Will probably fail spectacularly in some cases if the filesystem is
  * modified at the same time by another process while UAE is running.
  */

#if 1

#include "sysconfig.h"
#include "sysdeps.h"

#include "config.h"
#include "options.h"
#include "uae.h"
#include "my_memory.h"
#include "custom.h"
#include "readcpu.h"
#include "newcpu.h"
#include "xwin.h"
#include "filesys.h"
#include "autoconf.h"
#include "compiler.h"
#include "threaddep/penguin.h"

/////////// ATB ///////////

//sys.unistd.H
#define F_OK 0
#define X_OK 0x01
#define W_OK 0x02
#define R_OK 0x04

// sys/stat.h
#define S_IRWXU 0000700
#define S_IRUSR 0000400
#define S_IWUSR 0000200
#define S_IXUSR 0000100

// sys/errno.h
#define EACCES          13

// chmod
int chmod(const char *path, mode_t mode);

int chmod(const char *path, mode_t mode)
{
return 0;
}

#define DIR long

int access(const char *name, int mode)
{
    return -1;
}

/////////////////////////

#undef TRACING_ENABLED
#ifdef TRACING_ENABLED
#define TRACE(x)    do { sprintf x; write_log(warning_buffer); } while(0)
#define DUMPLOCK(u,x)    dumplock(u,x)
#else
#define TRACE(x)
#define DUMPLOCK(u,x)
#endif

#define MAKE_CASE_INSENSITIVE

/* errors */
#define ERROR_NO_FREE_STORE        103
#define ERROR_OBJECT_IN_USE        202
#define ERROR_OBJECT_EXISTS        203
#define ERROR_DIR_NOT_FOUND        204
#define ERROR_OBJECT_NOT_FOUND        205
#define ERROR_ACTION_NOT_KNOWN        209
#define ERROR_INVALID_LOCK        211
#define ERROR_OBJECT_WRONG_TYPE        212
#define ERROR_DISK_WRITE_PROTECTED    214
#define ERROR_DIRECTORY_NOT_EMPTY    216
#define ERROR_DEVICE_NOT_MOUNTED    218
#define ERROR_SEEK_ERROR        219
#define ERROR_DISK_FULL            221
#define ERROR_DELETE_PROTECTED        222
#define ERROR_WRITE_PROTECTED        223
#define ERROR_READ_PROTECTED        224
#define ERROR_NO_MORE_ENTRIES        232
#define ERROR_NOT_IMPLEMENTED        236


#ifndef DONT_HAVE_POSIX
static long dos_errno(void)
{
    int e = errno;

    switch(e) {
/*
     case ENOMEM:    return ERROR_NO_FREE_STORE;
     case EEXIST:    return ERROR_OBJECT_EXISTS;
     case EACCES:    return ERROR_WRITE_PROTECTED;
     case ENOENT:    return ERROR_OBJECT_NOT_FOUND;
     case ENOTDIR:    return ERROR_OBJECT_WRONG_TYPE;
     case ENOSPC:    return ERROR_DISK_FULL;
     case EBUSY:           return ERROR_OBJECT_IN_USE;
     case EISDIR:    return ERROR_OBJECT_WRONG_TYPE;
#if defined(ETXTBSY)
     case ETXTBSY:    return ERROR_OBJECT_IN_USE;
#endif
#if defined(EROFS)
     case EROFS:           return ERROR_DISK_WRITE_PROTECTED;
#endif
#if defined(ENOTEMPTY)
#if ENOTEMPTY != EEXIST
     case ENOTEMPTY:    return ERROR_DIRECTORY_NOT_EMPTY;
#endif
#endif
*/
     default:
    TRACE((warning_buffer, "Unimplemented error %s\n", strerror(e)));
    return ERROR_NOT_IMPLEMENTED;
    }
}
#endif

/*
 * This _should_ be no issue for us, but let's rather use a guaranteed
 * thread safe function if we have one.
 * Well, let's use it once it works.
 */
#if 0 && defined HAVE_READDIR_R

static struct dirent *my_readdir (DIR *dirstream, struct dirent *space)
{
    struct dirent *loc;
    if (readdir_r (dirstream, space, &loc) == 0) {
    /* Success */
    return loc;
    }
    return 0;
}

#else
#define my_readdir(dirstream, space) readdir(dirstream)
#endif

#define FS_STARTUP 0
#define FS_GO_DOWN 1

/* AmigaOS "keys" */
struct a_inode {
    struct a_inode *next, *prev;
    struct a_inode *parent;
    struct a_inode *child, *sibling; /* @@@ implement hash tables or something to make this efficient */
    char *aname;
    char *nname;
    int amigaos_mode;
    int shlock;
    uae_u32 uniq;
    unsigned int dir:1;
    unsigned int elock:1;
};

typedef struct {
    char *devname; /* device name, e.g. UAE0: */
    uaecptr devname_amiga;
    uaecptr startup;
    char *volname; /* volume name, e.g. CDROM, WORK, etc. */
    char *rootdir; /* root unix directory */
    int readonly; /* disallow write access? */
    int devno;
    smp_comm_pipe *unit_pipe, *back_pipe;
    penguin_id tid;
    struct _unit *volatile self;
} UnitInfo;

#define MAX_UNITS 20
static int num_units = 0, num_filesys_units = 0;
static UnitInfo ui[MAX_UNITS];
uaecptr filesys_initcode;
static uae_u32 fsdevname, hardfileseglist, filesys_configdev;
static uaecptr filesys_parampacket;

void add_filesys_unit(char *volname, char *rootdir, int readonly)
{
    if (num_units >= MAX_UNITS) {
    write_log ("Maximum number of file systems mounted.\n");
    return;
    }

    if (volname != 0) {
    num_filesys_units++;
    ui[num_units].volname = my_strdup(volname);
    } else
    ui[num_units].volname = 0;
    ui[num_units].rootdir = my_strdup(rootdir);
    ui[num_units].readonly = readonly;

    num_units++;
}

int kill_filesys_unit(char *volname)
{
    size_t l = strlen(volname);
    int i;

    if (l == 0)
    return -1;

    if (volname[l-1] == ':')
    l--;

    for (i = 0; i < num_units; i++) {
    if (ui[i].volname != 0
        && strlen(ui[i].volname) == l
        && strncmp(ui[i].volname, volname, l) == 0)
        break;
    }
    if (i == num_units)
    return -1;

    num_units--;
    for (; i < num_units; i++) {
    ui[i] = ui[i+1];
    }
    return 0;
}

void filesys_store_devinfo (uae_u8 *where)
{
    int i;

    do_put_mem_long ((uae_u32 *)where, EXPANSION_explibname);
    do_put_mem_long ((uae_u32 *)(where + 4), filesys_configdev);
    do_put_mem_long ((uae_u32 *)(where + 8), EXPANSION_doslibname);
    do_put_mem_long ((uae_u32 *)(where + 12), num_units);

    where += 16;

    for (i = 0; i < num_units; i++) {
    int is_hardfile = ui[i].volname == 0;
    uae_u32 *thisdev = (uae_u32 *)where;

    do_put_mem_long (thisdev, ui[i].devname_amiga);
    do_put_mem_long (thisdev + 1, is_hardfile ? ROM_hardfile_resname : fsdevname);
    do_put_mem_long (thisdev + 2, ui[i].devno);
    do_put_mem_long (thisdev + 3, is_hardfile);

    where += 16;
    }
}

int sprintf_filesys_unit(char *buffer, int num)
{
    if (num >= num_units)
    return -1;
    if (ui[num].volname != 0)
    sprintf(buffer, "%s: %s %s", ui[num].volname, ui[num].rootdir,
        ui[num].readonly ? "ro" : "");
    else
    sprintf(buffer, "Hardfile \"UAE0:\", size %d bytes",
        hardfile_size);
    return 0;
}

void write_filesys_config(FILE *f)
{
    int i;
    for (i = 0; i < num_units; i++) {
    if (ui[i].volname != 0) {
        fprintf(f, "-%c %s:%s\n", ui[i].readonly ? 'M' : 'm',
            ui[i].volname, ui[i].rootdir);
    }
    }
}

/* minimal AmigaDOS definitions */

/* field offsets in DosPacket */
#define dp_Type 8
#define dp_Res1    12
#define dp_Res2 16
#define dp_Arg1 20
#define dp_Arg2 24
#define dp_Arg3 28
#define dp_Arg4 32

/* result codes */
#define DOS_TRUE (-1L)
#define DOS_FALSE (0L)

/* packet types */
#define ACTION_CURRENT_VOLUME    7
#define ACTION_LOCATE_OBJECT    8
#define ACTION_RENAME_DISK    9
#define ACTION_FREE_LOCK    15
#define ACTION_DELETE_OBJECT    16
#define ACTION_RENAME_OBJECT    17
#define ACTION_COPY_DIR        19
#define ACTION_SET_PROTECT    21
#define ACTION_CREATE_DIR    22
#define ACTION_EXAMINE_OBJECT    23
#define ACTION_EXAMINE_NEXT    24
#define ACTION_DISK_INFO    25
#define ACTION_INFO        26
#define ACTION_FLUSH        27
#define ACTION_SET_COMMENT    28
#define ACTION_PARENT        29
#define ACTION_SET_DATE        34
#define ACTION_SAME_LOCK    40
#define ACTION_FIND_WRITE    1004
#define ACTION_FIND_INPUT    1005
#define ACTION_FIND_OUTPUT    1006
#define ACTION_END        1007
#define ACTION_SEEK        1008
#define ACTION_IS_FILESYSTEM    1027
#define ACTION_READ        'R'
#define ACTION_WRITE        'W'

#define DISK_TYPE        0x444f5301 /* DOS\1 */

typedef struct {
    uae_u32 uniq;
    struct a_inode *aino;
    DIR* dir;
} ExamineKey;

typedef struct key {
    struct key *next;
    struct a_inode *aino;
    uae_u32 uniq;
    int fd;
    off_t file_pos;
} Key;

/* Since ACTION_EXAMINE_NEXT is so braindamaged, we have to keep
 * some of these around
 */

#define EXKEYS 100
#define MAX_AINO_HASH 128

/* handler state info */

typedef struct _unit {
    struct _unit *next;

    /* Amiga stuff */
    uaecptr    dosbase;
    uaecptr    volume;
    uaecptr    port;    /* Our port */
    uaecptr    locklist;

    /* Native stuff */
    uae_s32    unit;    /* unit number */
    UnitInfo    ui;    /* unit startup info */
    char    tmpbuf3[256];

    /* Dummy message processing */
    uaecptr    dummy_message;
    volatile unsigned int cmds_sent;
    volatile unsigned int cmds_complete;
    volatile unsigned int cmds_acked;

    /* ExKeys */
    ExamineKey    examine_keys[EXKEYS];
    int        next_exkey;

    /* Keys */
    struct key*    keys;
    uae_u32    key_uniq;
    uae_u32    a_uniq;

    struct a_inode rootnode;
    unsigned long aino_cache_size;
    struct a_inode *aino_hash[MAX_AINO_HASH];
    unsigned long nr_cache_hits;
    unsigned long nr_cache_lookups;

    /* Reset handling */
    uae_sem_t    reset_sync_sem;
    int        reset_state;
} Unit;

typedef uae_u8 *dpacket;
#define PUT_PCK_RES1(p,v) do { do_put_mem_long ((uae_u32 *)((p) + dp_Res1), (v)); } while (0)
#define PUT_PCK_RES2(p,v) do { do_put_mem_long ((uae_u32 *)((p) + dp_Res2), (v)); } while (0)
#define GET_PCK_TYPE(p) ((uae_s32)(do_get_mem_long ((uae_u32 *)((p) + dp_Type))))
#define GET_PCK_RES1(p) ((uae_s32)(do_get_mem_long ((uae_u32 *)((p) + dp_Res1))))
#define GET_PCK_RES2(p) ((uae_s32)(do_get_mem_long ((uae_u32 *)((p) + dp_Res2))))
#define GET_PCK_ARG1(p) ((uae_s32)(do_get_mem_long ((uae_u32 *)((p) + dp_Arg1))))
#define GET_PCK_ARG2(p) ((uae_s32)(do_get_mem_long ((uae_u32 *)((p) + dp_Arg2))))
#define GET_PCK_ARG3(p) ((uae_s32)(do_get_mem_long ((uae_u32 *)((p) + dp_Arg3))))
#define GET_PCK_ARG4(p) ((uae_s32)(do_get_mem_long ((uae_u32 *)((p) + dp_Arg4))))

static char *bstr1 (uaecptr addr)
{
    static char buf[256];
    int i;
    int n = get_byte(addr);
    addr++;

    for(i = 0; i < n; i++, addr++)
    buf[i] = get_byte(addr);
    buf[i] = 0;
    return buf;
}

static char *bstr (Unit *unit, uaecptr addr)
{
    int i;
    int n = get_byte(addr);

    addr++;
    for(i = 0; i < n; i++, addr++)
    unit->tmpbuf3[i] = get_byte(addr);
    unit->tmpbuf3[i] = 0;
    return unit->tmpbuf3;
}

static char *bstr_cut (Unit *unit, uaecptr addr)
{
    char *p = unit->tmpbuf3;
    int i, colon_seen = 0;
    int n = get_byte (addr);

    addr++;
    for(i = 0; i < n; i++, addr++) {
    uae_u8 c = get_byte(addr);
    unit->tmpbuf3[i] = c;
    if (c == '/' || (c == ':' && colon_seen++ == 0))
        p = unit->tmpbuf3 + i + 1;
    }
    unit->tmpbuf3[i] = 0;
    return p;
}

static Unit *units = 0;
static int unit_num = 0;

static Unit*
find_unit(uaecptr port)
{
    Unit* u;
    for(u = units; u; u = u->next)
    if(u->port == port)
        break;

    return u;
}

static int get_file_attrs (struct a_inode *aino)
{
    struct stat statbuf;
    if (-1 == stat (aino->nname, &statbuf))
    return dos_errno ();
    aino->dir = S_ISDIR (statbuf.st_mode) ? 1 : 0;
    aino->amigaos_mode =
#ifndef __DOS__
    (S_IXUSR & statbuf.st_mode ? 0 : A_FIBF_EXECUTE) |
#endif
    (S_IWUSR & statbuf.st_mode ? 0 : A_FIBF_WRITE) |
#if 0 /* This makes it impossible to overwrite those. */
    (S_IWUSR & statbuf.st_mode ? 0 : A_FIBF_DELETE) |
#endif
    (S_IRUSR & statbuf.st_mode ? 0 : A_FIBF_READ);
    return 0;
};

static int set_file_attrs (struct a_inode *aino, int mask)
{
    struct stat statbuf;
    int mode;

    if (-1 == stat(aino->nname, &statbuf))
    return ERROR_OBJECT_NOT_FOUND;

    mode = statbuf.st_mode;
#ifdef __unix
    /* Unix dirs behave differently than AmigaOS ones. Just allow anything. */
    if (aino->dir) {
    mask = 0;
    }
#endif
    if (mask & A_FIBF_READ)
    mode &= ~S_IRUSR;
    else
    mode |= S_IRUSR;

    if ((mask & A_FIBF_WRITE) != 0 || (mask & A_FIBF_DELETE) != 0)
    mode &= ~S_IWUSR;
    else
    mode |= S_IWUSR;

    if (mask & A_FIBF_EXECUTE)
    mode &= ~S_IXUSR;
    else
    mode |= S_IXUSR;

    if (-1 == chmod(aino->nname, mode))
    return dos_errno();

    aino->amigaos_mode = mask;

    return 0;
}

static void prepare_for_open (char *name)
{
#if 0
    struct stat statbuf;
    int mode;

    if (-1 == stat (name, &statbuf))
    return;

    mode = statbuf.st_mode;
    mode |= S_IRUSR;
    mode |= S_IWUSR;
    mode |= S_IXUSR;
    chmod (name, mode);
#endif
}

static void de_recycle_aino (Unit *unit, struct a_inode *aino)
{
    if (aino->next == 0 || aino == &unit->rootnode)
    return;
    aino->next->prev = aino->prev;
    aino->prev->next = aino->next;
    aino->next = aino->prev = 0;
    unit->aino_cache_size--;
}

static void recycle_aino (Unit *unit, struct a_inode *aino)
{
    if (aino->dir || aino->shlock > 0 || aino->elock || aino == &unit->rootnode)
    /* Still in use */
    return;

    /* Chain it into circular list. */
    aino->next = unit->rootnode.next;
    aino->prev = &unit->rootnode;
    aino->prev->next = aino;
    aino->next->prev = aino;
    unit->aino_cache_size++;
    if (unit->aino_cache_size > 500) {
    /* Reap a few. */
    int i = 0;
    while (i < 50) {
        struct a_inode **aip;
        aip = &unit->rootnode.prev->parent->child;
        for (;;) {
        aino = *aip;
        if (aino == 0)
            break;

        if (aino->next == 0)
            aip = &aino->sibling;
        else {
            int hash = aino->uniq % MAX_AINO_HASH;
            if (unit->aino_hash[hash] == aino)
            unit->aino_hash[hash] = 0;

            aino->next->prev = aino->prev;
            aino->prev->next = aino->next;
            *aip = aino->sibling;
            i++;

            if (aino->shlock > 0 || aino->elock)
            write_log ("panic: freeing locked a_inode!\n");

            free (aino->nname);
            free (aino->aname);
            free (aino);
        }
        }
    }
#if 0
    {
        char buffer[40];
        sprintf (buffer, "%d ainos reaped.\n", i);
        write_log (buffer);
    }
#endif
    unit->aino_cache_size -= i;
    }
}

static void update_child_names (Unit *unit, struct a_inode *a, struct a_inode *parent)
{
    int l0 = strlen (parent->nname) + 2;

    while (a != 0) {
    char *name_start;
    char *new_name;

    a->parent = parent;
    name_start = strrchr (a->nname, '/');
    if (name_start == 0) {
        write_log ("malformed file name");
    }
    name_start++;
    new_name = malloc (strlen (name_start) + l0);
    strcpy (new_name, parent->nname);
    strcat (new_name, "/");
    strcat (new_name, name_start);
    free (a->nname);
    a->nname = new_name;
    if (a->child)
        update_child_names (unit, a->child, a);
    a = a->sibling;
    }
}

static void move_aino_children (Unit *unit, struct a_inode *from, struct a_inode *to)
{
    to->child = from->child;
    from->child = 0;
    update_child_names (unit, to->child, to);
}

static void delete_aino (Unit *unit, struct a_inode *aino)
{
    struct a_inode **aip;
    int hash;

    TRACE((warning_buffer, "deleting aino %x\n", aino->uniq));

    de_recycle_aino (unit, aino);
    aip = &aino->parent->child;
    while (*aip != aino && *aip != 0)
    aip = &(*aip)->sibling;
    if (*aip != aino) {
    write_log ("Couldn't delete aino.\n");
    return;
    }
    hash = aino->uniq % MAX_AINO_HASH;
    if (unit->aino_hash[hash] == aino)
        unit->aino_hash[hash] = 0;
    *aip = aino->sibling;
    free (aino->nname);
    free (aino->aname);
    free (aino);
}

static struct a_inode *lookup_sub (struct a_inode *dir, uae_u32 uniq)
{
    struct a_inode **cp = &dir->child;
    struct a_inode *c, *retval;

    for (;;) {
    c = *cp;
    if (c == 0)
        return 0;

    if (c->uniq == uniq) {
        retval = c;
        break;
    }
    if (c->dir) {
        struct a_inode *a = lookup_sub (c, uniq);
        if (a != 0) {
        retval = a;
        break;
        }
    }
    cp = &c->sibling;
    }
    *cp = c->sibling;
    c->sibling = dir->child;
    dir->child = c;
    return retval;
}

static struct a_inode *lookup_aino (Unit *unit, uae_u32 uniq)
{
    struct a_inode *a;
    int hash = uniq % MAX_AINO_HASH;

    if (uniq == 0)
    return &unit->rootnode;
    a = unit->aino_hash[hash];
    if (a == 0 || a->uniq != uniq)
    a = lookup_sub (&unit->rootnode, uniq);
    else
    unit->nr_cache_hits++;
    unit->nr_cache_lookups++;
    unit->aino_hash[hash] = a;
    return a;
}

/* This gets called to translate an Amiga name that some program used to
 * a name that we can use on the native filesystem. */
static char *get_nname (Unit *unit, struct a_inode *base, char *rel)
{
#if 0
    DIR* dir;
    struct dirent* de;
    char *p = 0;

    dir = opendir(base->nname);
    if (dir) {
    struct dirent de_space;
    while((de = my_readdir (dir, &de_space))) {
        if (strcasecmp(de->d_name, rel) == 0)
        break;
    }
    if (de) {
        p = malloc (strlen (de->d_name) + strlen (base->nname) + 2);
        if (p != 0) {
        strcpy (p, base->nname);
        strcat (p, "/");
        strcat (p, de->d_name);
        }
    }
    closedir(dir);
    }
    return p;
#endif
}

/*
 * This gets called if an ACTION_EXAMINE_NEXT happens and we hit an object
 * for which we know the name on the native filesystem, but no corresponding
 * Amiga filesystem name.
 * @@@ For DOS filesystems, it might make sense to declare the new name
 * "weak", so that it can get overriden by a subsequent call to get_nname().
 * That way, if someone does "dir :" and there is a file "foobar.inf", and
 * someone else tries to open "foobar.info", get_nname() could maybe made to
 * figure out that this is supposed to be the file "foobar.inf".
 * DOS sucks...
 */
static char *get_aname (Unit *unit, struct a_inode *base, char *rel)
{
    char *p = 0;

    p = malloc (strlen (rel) + strlen (base->aname) + 2);
    if (p != 0) {
    strcpy (p, base->aname);
    strcat (p, "/");
    strcat (p, rel);
    }
    return p;
}

static struct a_inode *new_child_aino (Unit *unit, struct a_inode *base, char *rel, int force)
{
    struct stat statbuf;
    char *nn;
    struct a_inode *aino;

    nn = get_nname (unit, base, rel);
    if (nn == 0 && !force)
    return 0;
    else if (nn != 0)
    force = 0;

    aino = malloc (sizeof (struct a_inode));
    if (aino == 0)
    return 0;
    aino->aname = my_strdup (rel);
    if (nn == 0) {
    nn = malloc (strlen (base->nname) + strlen (rel) + 2);
    strcpy (nn, base->nname);
    strcat (nn, "/");
    strcat (nn, rel);
    free (rel);
    }
    aino->nname = nn;
    aino->uniq = ++unit->a_uniq;
    if (unit->a_uniq == 0xFFFFFFFF) {
    write_log ("Running out of a_inodes (prepare for big trouble)!\n");
    }
    aino->shlock = 0;
    aino->elock = 0;

    /* Update tree structure */
    aino->parent = base;
    aino->child = 0;
    aino->sibling = base->child;
    base->child = aino;
    aino->next = aino->prev = 0;

    if (force == 2) {
    aino->dir = 1;
    aino->amigaos_mode = 0;
    } else if (force == 1) {
    aino->dir = 0;
    aino->amigaos_mode = 0;
    } else {
    get_file_attrs (aino);
    }
    recycle_aino (unit, aino);
    TRACE((warning_buffer, "created aino %x, normal\n", aino->uniq));
    return aino;
}

static struct a_inode *lookup_child_aino (Unit *unit, struct a_inode *base, char *rel, uae_u32 *err)
{
 #if 0
    struct a_inode *c = base->child;
    char *p, *p2;
    int l0 = strlen (rel);

    if (base->dir == 0) {
    *err = ERROR_OBJECT_WRONG_TYPE;
    return 0;
    }

    while (c != 0) {
    int l1 = strlen (c->aname);
    if (l0 <= l1 && strcasecmp (rel, c->aname + l1 - l0) == 0
        && (l0 == l1 || c->aname[l1-l0-1] == '/'))
        break;
    c = c->sibling;
    }
    if (c != 0)
    return c;
    c = new_child_aino (unit, base, rel, 0);
    if (c == 0)
    *err = ERROR_OBJECT_NOT_FOUND;
    return c;
#endif
}

/* Different version because this one compares with the nname */
static struct a_inode *lookup_child_aino_for_exnext (Unit *unit, struct a_inode *base, char *rel, uae_u32 *err)
{
    struct a_inode *c = base->child;
    char *p, *p2;
    int l0 = strlen (rel);

    *err = 0;
    while (c != 0) {
    int l1 = strlen (c->nname);
    if (l0 <= l1 && strcasecmp (rel, c->nname + l1 - l0) == 0
        && (l0 == l1 || c->nname[l1-l0-1] == '/'))
        break;
    c = c->sibling;
    }
    if (c != 0)
    return c;
    c = malloc (sizeof (struct a_inode));
    if (c == 0)
    *err = ERROR_NO_FREE_STORE;
    else {
    c->nname = malloc (strlen (base->nname) + l0 + 2);
    strcpy (c->nname, base->nname);
    strcat (c->nname, "/");
    strcat (c->nname, rel);
    c->aname = get_aname (unit, base, rel);
    c->uniq = ++unit->a_uniq;
    if (unit->a_uniq == 0xFFFFFFFF) {
        write_log ("Running out of a_inodes (prepare for big trouble)!\n");
    }
    c->shlock = 0;
    c->elock = 0;

    /* Update tree structure */
    c->parent = base;
    c->child = 0;
    c->sibling = base->child;
    base->child = c;
    c->next = c->prev = 0;

    get_file_attrs (c);
    recycle_aino (unit, c);
    TRACE((warning_buffer, "created aino %x, exnext\n", c->uniq));
    }
    return c;
}

static struct a_inode *get_aino(Unit* unit, struct a_inode *base, const char *rel, uae_u32 *err)
{
    char *tmp;
    char *p;
    char *r;
    struct a_inode *curr;
    int i;

    *err = 0;
    TRACE((warning_buffer, "get_path(%s,%s)\n", base->aname, rel));

    /* root-relative path? */
    for(i = 0; rel[i] && rel[i] != '/' && rel[i] != ':'; i++)
    ;
    if (':' == rel[i])
    rel += i+1;

    tmp = my_strdup (rel);
    p = tmp;
    curr = base;

    while(*p) {
    /* start with a slash? go up a level. */
    if (*p == '/') {
        if (curr->parent != 0)
        curr = curr->parent;
        p++;
    } else {
        struct a_inode *next;

        char *component_end;
        component_end = strchr (p, '/');
        if (component_end != 0)
        *component_end = '\0';
        next = lookup_child_aino (unit, curr, p, err);
        if (next == 0) {
        /* if only last component not found, return parent dir. */
        if (*err != ERROR_OBJECT_NOT_FOUND || component_end != 0)
            curr = 0;
        /* ? what error is appropriate? */
        break;
        }
        curr = next;
        if (component_end)
        p = component_end+1;
        else
        break;

    }
    }
    free (tmp);
    return curr;
}

static uae_u32 startup_handler (void)
{
    /* Just got the startup packet. It's in A4. DosBase is in A2,
     * our allocated volume structure is in D6, A5 is a pointer to
     * our port. */
    uaecptr rootnode = get_long(m68k_areg (regs, 2) + 34);
    uaecptr dos_info = get_long(rootnode + 24) << 2;
    uaecptr pkt = m68k_dreg (regs, 3);
    uaecptr arg2 = get_long (pkt + dp_Arg2);
    int i, namelen;
    char* devname = bstr1 (get_long (pkt + dp_Arg1) << 2);
    char* s;
    Unit* unit;
    UnitInfo *uinfo;

    /* find UnitInfo with correct device name */
    s = strchr(devname, ':');
    if(s)
    *s = '\0';

    for(i = 0; i < num_units; i++) {
    /* Hardfile volume name? */
    if (ui[i].volname == 0)
        continue;

    if (ui[i].startup == arg2)
        break;
    }

    if(i == num_units || 0 != access(ui[i].rootdir, R_OK)) {
    sprintf(warning_buffer, "Failed attempt to mount device\n", devname);
    write_log (warning_buffer);
    put_long (pkt + dp_Res1, DOS_FALSE);
    put_long (pkt + dp_Res2, ERROR_DEVICE_NOT_MOUNTED);
    return 1;
    }
    uinfo = ui + i;

    unit = (Unit *) malloc (sizeof (Unit));
    unit->next = units;
    units = unit;
    uinfo->self = unit;

    unit->volume = 0;
    unit->reset_state = FS_STARTUP;
    unit->port = m68k_areg(regs, 5);
    unit->unit = unit_num++;

    unit->ui.devname = uinfo->devname;
    unit->ui.volname = my_strdup (uinfo->volname); /* might free later for rename */
    unit->ui.rootdir = uinfo->rootdir;
    unit->ui.readonly = uinfo->readonly;
    unit->ui.unit_pipe = uinfo->unit_pipe;
    unit->ui.back_pipe = uinfo->back_pipe;
    unit->cmds_complete = 0;
    unit->cmds_sent = 0;
    unit->cmds_acked = 0;
    for (i = 0; i < EXKEYS; i++) {
    unit->examine_keys[i].aino = 0;
    unit->examine_keys[i].dir = 0;
    unit->examine_keys[i].uniq = 0;
    }
    unit->next_exkey = 1;
    unit->keys = 0;
    unit->a_uniq = unit->key_uniq = 0;

    unit->rootnode.aname = uinfo->volname;
    unit->rootnode.nname = uinfo->rootdir;
    unit->rootnode.sibling = 0;
    unit->rootnode.next = unit->rootnode.prev = &unit->rootnode;
    unit->rootnode.uniq = 0;
    unit->rootnode.parent = 0;
    unit->rootnode.child = 0;
    unit->rootnode.dir = 1;
    unit->rootnode.amigaos_mode = 0;
    unit->rootnode.shlock = 0;
    unit->rootnode.elock = 0;
    unit->aino_cache_size = 0;
    for (i = 0; i < MAX_AINO_HASH; i++)
    unit->aino_hash[i] = 0;

/*    write_comm_pipe_int (unit->ui.unit_pipe, -1, 1);*/

    TRACE((warning_buffer, "**** STARTUP volume %s\n", unit->ui.volname));

    /* fill in our process in the device node */
    put_long ((get_long (pkt + dp_Arg3) << 2) + 8, unit->port);
    unit->dosbase = m68k_areg(regs, 2);

    /* make new volume */
    unit->volume = m68k_areg (regs, 3) + 32;
#ifdef SUPPORT_THREADS
    unit->locklist = m68k_areg (regs, 3) + 8;
#else
    unit->locklist = m68k_areg (regs, 3);
#endif
    unit->dummy_message = m68k_areg (regs, 3) + 12;

    put_long (unit->dummy_message + 10, 0);

    put_long (unit->volume + 4, 2); /* Type = dt_volume */
    put_long (unit->volume + 12, 0); /* Lock */
    put_long (unit->volume + 16, 3800); /* Creation Date */
    put_long (unit->volume + 20, 0);
    put_long (unit->volume + 24, 0);
    put_long (unit->volume + 28, 0); /* lock list */
    put_long (unit->volume + 40, (unit->volume + 44) >> 2); /* Name */
    namelen = strlen (unit->ui.volname);
    put_byte (unit->volume + 44, namelen);
    for(i = 0; i < namelen; i++)
    put_byte (unit->volume + 45 + i, unit->ui.volname[i]);

    /* link into DOS list */
    put_long (unit->volume, get_long(dos_info + 4));
    put_long (dos_info + 4, unit->volume >> 2);

    put_long (unit->volume + 8, unit->port);
    put_long (unit->volume + 32, DISK_TYPE);

    put_long (pkt + dp_Res1, DOS_TRUE);
    return 0;
}

#ifdef HAVE_STATFS
static void
do_info(Unit* unit, dpacket packet, uaecptr info)
{
    struct statfs statbuf;
#if STATFS_NO_ARGS == 2
    if(-1 == statfs(unit->ui.rootdir, &statbuf))
#else
    if(-1 == statfs(unit->ui.rootdir, &statbuf, sizeof(struct statfs), 0))
#endif
    {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, dos_errno ());
    }

    put_long(info, 0); /* errors */
    put_long(info + 4, unit->unit); /* unit number */
    put_long(info + 8, unit->ui.readonly ? 80 : 82); /* state  */
    put_long(info + 12, statbuf.f_blocks); /* numblocks */
    put_long(info + 16, statbuf.f_blocks - statbuf.STATBUF_BAVAIL); /* inuse */
    put_long(info + 20, statbuf.f_bsize); /* bytesperblock */
    put_long(info + 24, DISK_TYPE); /* disk type */
    put_long(info + 28, unit->volume >> 2); /* volume node */
    put_long(info + 32, 0); /* inuse */
    PUT_PCK_RES1 (packet, DOS_TRUE);
}
#else
static void
do_info(Unit* unit, dpacket packet, uaecptr info)
{
    put_long(info, 0); /* errors */
    put_long(info + 4, unit->unit); /* unit number */
    put_long(info + 8, unit->ui.readonly ? 80 : 82); /* state  */
    put_long(info + 12, 256); /* numblocks */
    put_long(info + 16, 128); /* inuse */
    put_long(info + 20, 512); /* bytesperblock */
    put_long(info + 24, DISK_TYPE); /* disk type */
    put_long(info + 28, unit->volume >> 2); /* volume node */
    put_long(info + 32, 0); /* inuse */
    PUT_PCK_RES1 (packet, DOS_TRUE);
}
#endif

static void
action_disk_info(Unit* unit, dpacket packet)
{
    TRACE((warning_buffer, "ACTION_DISK_INFO\n"));
    do_info(unit, packet, GET_PCK_ARG1 (packet) << 2);
}

static void
action_info(Unit* unit, dpacket packet)
{
    TRACE((warning_buffer, "ACTION_INFO\n"));
    do_info(unit, packet, GET_PCK_ARG2 (packet) << 2);
}

static void free_key (Unit *unit, Key*k)
{
    Key *k1;
    Key *prev = 0;
    for (k1 = unit->keys; k1; k1 = k1->next) {
        if (k == k1) {
            if(prev)
                prev->next = k->next;
            else
                unit->keys = k->next;
            break;
        }
        prev = k1;
    }

    if (k->fd >= 0)
    close(k->fd);

    free(k);
}

static Key *lookup_key(Unit *unit, uae_u32 uniq)
{
    Key *k;
    /* It's hardly worthwhile to optimize this - most of the time there are
     * only one or zero keys. */
    for(k = unit->keys; k; k = k->next) {
        if (uniq == k->uniq)
            return k;
    }
    write_log ("Error: couldn't find key!\n");
#if 0
    exit(1);
    /* NOTREACHED */
#endif
    /* There isn't much hope we will recover. Unix would kill the process,
     * AmigaOS gets killed by it. */
    write_log ("Better reset that Amiga - the system is messed up.\n");
    return 0;
}

static Key *new_key(Unit *unit)
{
    Key *k = (Key*) malloc(sizeof(Key));
    k->uniq = ++unit->key_uniq;
    k->fd = -1;
    k->file_pos = 0;
    k->next = unit->keys;
    unit->keys = k;

    return k;
}

static void
dumplock(Unit *unit, uaecptr lock)
{
    struct a_inode *a;
    TRACE((warning_buffer, "LOCK: 0x%lx", lock));
    if(!lock) {
    TRACE((warning_buffer, "\n"));
    return;
    }
    TRACE((warning_buffer, "{ next=0x%lx, mode=%ld, handler=0x%lx, volume=0x%lx, aino %lx ",
       get_long(lock) << 2, get_long(lock+8),
       get_long(lock+12), get_long(lock+16),
       get_long(lock + 4)));
    a = lookup_aino (unit, get_long (lock + 4));
    if (a == 0) {
    TRACE((warning_buffer, "not found!"));
    } else {
    TRACE((warning_buffer, "%s", a->nname));
    }
    TRACE((warning_buffer, " }\n"));
}

static struct a_inode *find_aino(Unit* unit, uaecptr lock, const char *name, uae_u32 *err)
{
    struct a_inode *a;

    if (lock) {
    struct a_inode *olda = lookup_aino (unit, get_long(lock + 4));
    if (olda == 0) {
        /* That's the best we can hope to do. */
        a = get_aino (unit, &unit->rootnode, name, err);
    } else {
        TRACE((warning_buffer, "aino: 0x%08lx", (unsigned long int)olda->uniq));
        TRACE((warning_buffer, " \"%s\"\n", olda->nname));
        a = get_aino (unit, olda, name, err);
    }
    } else {
    a = get_aino (unit, &unit->rootnode, name, err);
    }
    if (a) {
    TRACE((warning_buffer, "aino=\"%s\"\n", a->nname));
    }
    return a;
}

static uaecptr make_lock (Unit* unit, uae_u32 uniq, long mode)
{
    /* allocate lock from the list kept by the assembly code */
    uaecptr lock;

    lock = get_long (unit->locklist);
    put_long (unit->locklist, get_long (lock));
    lock += 4;

    put_long(lock + 4, uniq);
    put_long(lock + 8, mode);
    put_long(lock + 12, unit->port);
    put_long(lock + 16, unit->volume >> 2);

    /* prepend to lock chain */
    put_long(lock, get_long(unit->volume + 28));
    put_long(unit->volume + 28, lock >> 2);

    DUMPLOCK(unit, lock);
    return lock;
}

static void free_lock (Unit* unit, uaecptr lock)
{
    Key *k;
    if(!lock)
    return;

    if (lock == get_long(unit->volume + 28) << 2) {
    put_long(unit->volume + 28, get_long(lock));
    } else {
    uaecptr current = get_long(unit->volume + 28);
    uaecptr next = 0;
    while(current) {
        next = get_long(current << 2);
        if(lock == next << 2)
        break;
        current = next;
    }
    put_long(current << 2, get_long(lock));
    }
    lock -= 4;
    put_long (lock, get_long (unit->locklist));
    put_long (unit->locklist, lock);
}

static void
action_lock(Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG1 (packet) << 2;
    uaecptr name = GET_PCK_ARG2 (packet) << 2;
    long mode = GET_PCK_ARG3 (packet);
    struct a_inode *a;
    uae_u32 err;

    if (mode != -2 && mode != -1) {
    TRACE((warning_buffer, "Bad mode.\n"));
    mode = -2;
    }

    TRACE((warning_buffer, "ACTION_LOCK(0x%lx, \"%s\", %d)\n", lock, bstr (unit, name), mode));
    DUMPLOCK(unit, lock);

    a = find_aino (unit, lock, bstr (unit, name), &err);
    if (err == 0 && (a->elock || (mode != -2 && a->shlock > 0))) {
    err = ERROR_OBJECT_IN_USE;
    }
    /* Lock() doesn't do access checks. */
    if (err != 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err);
    return;
    }
    if (mode == -2)
    a->shlock++;
    else
    a->elock = 1;
    de_recycle_aino (unit, a);
    PUT_PCK_RES1 (packet, make_lock (unit, a->uniq, mode) >> 2);
}

static void action_free_lock (Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG1 (packet) << 2;
    struct a_inode *a;
    TRACE((warning_buffer, "ACTION_FREE_LOCK(0x%lx)\n", lock));
    DUMPLOCK(unit, lock);

    a = lookup_aino (unit, get_long (lock + 4));
    if (a == 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_FOUND);
    return;
    }
    if (a->elock)
    a->elock = 0;
    else
    a->shlock--;
    recycle_aino (unit, a);
    free_lock(unit, lock);

    PUT_PCK_RES1 (packet, DOS_TRUE);
}

static void
action_dup_lock(Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG1 (packet) << 2;
    struct a_inode *a;
    TRACE((warning_buffer, "ACTION_DUP_LOCK(0x%lx)\n", lock));
    DUMPLOCK(unit, lock);

    if(!lock) {
    PUT_PCK_RES1 (packet, 0);
    return;
    }
    a = lookup_aino (unit, get_long (lock + 4));
    if (a == 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_FOUND);
    return;
    }
    /* DupLock()ing exclusive locks isn't possible, says the Autodoc, but
     * at least the RAM-Handler seems to allow it. Let's see what happens
     * if we don't. */
    if (a->elock) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_OBJECT_IN_USE);
    return;
    }
    a->shlock++;
    de_recycle_aino (unit, a);
    PUT_PCK_RES1 (packet, make_lock (unit, a->uniq, -2) >> 2);
}

/* convert time_t to/from AmigaDOS time */
const int secs_per_day = 24 * 60 * 60;
const int diff = (8 * 365 + 2) * (24 * 60 * 60);

static void
get_time(time_t t, long* days, long* mins, long* ticks)
{
    /* time_t is secs since 1-1-1970 */
    /* days since 1-1-1978 */
    /* mins since midnight */
    /* ticks past minute @ 50Hz */

    t -= diff;
    *days = t / secs_per_day;
    t -= *days * secs_per_day;
    *mins = t / 60;
    t -= *mins * 60;
    *ticks = t * 50;
}

static time_t
put_time(long days, long mins, long ticks)
{
    time_t t;
    t = ticks / 50;
    t += mins * 60;
    t += days * secs_per_day;
    t += diff;

    return t;
}

static void free_exkey(ExamineKey* ek)
{
    ek->aino = 0;
    ek->uniq = 0;
//    if (ek->dir)
//    closedir (ek->dir);
}

/* This is so sick... who invented ACTION_EXAMINE_NEXT? What did he THINK??? */
static ExamineKey *new_exkey(Unit *unit, struct a_inode *aino)
{
    uae_u32 uniq;
    uae_u32 oldest = 0xFFFFFFFF;
    ExamineKey *ek, *oldest_ek = 0;
    int i;

    ek = unit->examine_keys;
    for (i = 0; i < EXKEYS; i++, ek++) {
    /* Did we find a free one? */
    if (ek->aino == 0)
        continue;
    if (ek->uniq < oldest)
        oldest = (oldest_ek = ek)->uniq;
    }
    ek = unit->examine_keys;
    for (i = 0; i < EXKEYS; i++, ek++) {
    /* Did we find a free one? */
    if (ek->aino == 0)
        goto found;
    }
    /* This message should usually be harmless. */
    write_log ("Houston, we have a problem.\n");
    free_exkey (oldest_ek);
    ek = oldest_ek;
    found:

    uniq = unit->next_exkey;
    if (uniq == 0xFFFFFFFF) {
    /* Things will probably go wrong, but most likely the Amiga will crash
     * before this happens because of something else. */
    uniq = 1;
    }
    unit->next_exkey = uniq+1;
    ek->aino = aino;
    ek->dir = 0;
    ek->uniq = uniq;
    return ek;
}

static ExamineKey *lookup_exkey(Unit *unit, uae_u32 uniq)
{
    ExamineKey *ek;
    int i;

    ek = unit->examine_keys;
    for (i = 0; i < EXKEYS; i++, ek++) {
    /* Did we find a free one? */
    if (ek->uniq == uniq)
        return ek;
    }
    write_log ("Houston, we have a BIG problem.\n");
    return 0;
}

static void
get_fileinfo(Unit *unit, dpacket packet, uaecptr info, struct a_inode *aino)
{
    struct stat statbuf;
    long days, mins, ticks;
    int i, n;
    char *x;
    uae_u32 err;

    /* No error checks - this had better work. */
    stat (aino->nname, &statbuf);

    if (aino->parent == 0) {
    x = unit->ui.volname;
    put_long (info + 4, 1);
    put_long (info + 120, 1);
    } else {
    /* AmigaOS docs say these have to contain the same value. */
    put_long(info + 4, aino->dir ? 2 : -3);
    put_long(info + 120, aino->dir ? 2 : -3);
    x = strrchr (aino->aname, '/');
    if (x)
        x++;
    else
        x = aino->aname;
    }
    TRACE((warning_buffer, "name=\"%s\"\n", x));
    n = strlen(x);
    if (n > 106)
    n = 106;
    i = 8;
    put_byte(info + i, n); i++;
    while(n--)
    put_byte(info + i, *x), i++, x++;
    while(i < 108)
    put_byte(info + i, 0), i++;

    put_long (info + 116, aino->amigaos_mode);
    put_long(info + 124, statbuf.st_size);
#ifdef HAVE_ST_BLOCKS
    put_long(info + 128, statbuf.st_blocks);
#else
    put_long(info + 128, statbuf.st_size / 512 + 1);
#endif
    get_time(statbuf.st_mtime, &days, &mins, &ticks);
    put_long(info + 132, days);
    put_long(info + 136, mins);
    put_long(info + 140, ticks);
    put_long(info + 144, 0); /* no comment */
    PUT_PCK_RES1 (packet, DOS_TRUE);
}

static void do_examine(Unit *unit, dpacket packet, ExamineKey* ek, uaecptr info)
{
#if 0
    struct dirent de_space;
    struct dirent* de;
    struct a_inode *aino;
    uae_u32 err;

    if (!ek->dir) {
    ek->dir = opendir (ek->aino->nname);
    }
    if (!ek->dir) {
    free_exkey (ek);
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_NO_MORE_ENTRIES);
    return;
    }

    de = my_readdir (ek->dir, &de_space);

    while (de && (0 == strcmp(".", de->d_name)
         || 0 == strcmp("..", de->d_name)))
    {
    de = my_readdir (ek->dir, &de_space);
    }

    if (!de) {
    TRACE((warning_buffer, "no more entries\n"));
    free_exkey (ek);
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_NO_MORE_ENTRIES);
    return;
    }

    TRACE((warning_buffer, "entry=\"%s\"\n", de->d_name));
    aino = lookup_child_aino_for_exnext (unit, ek->aino, de->d_name, &err);
    if (err != 0) {
    write_log ("Severe problem in ExNext.\n");
    free_exkey (ek);
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err);
    }
    get_fileinfo (unit, packet, info, aino);
#endif
}

static void action_examine_object (Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG1 (packet) << 2;
    uaecptr info = GET_PCK_ARG2 (packet) << 2;
    ExamineKey* ek;
    struct a_inode *aino = 0;

    TRACE((warning_buffer, "ACTION_EXAMINE_OBJECT(0x%lx,0x%lx)\n", lock, info));
    DUMPLOCK(unit, lock);

    if (lock != 0)
    aino = lookup_aino (unit, get_long(lock + 4));
    if (aino == 0)
    aino = &unit->rootnode;

    get_fileinfo (unit, packet, info, aino);
    if (aino->dir) {
    put_long(info, 0xFFFFFFFF);
    } else
    put_long(info, 0);
}

static void action_examine_next(Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG1 (packet) << 2;
    uaecptr info = GET_PCK_ARG2 (packet) << 2;
    struct a_inode *aino = 0;
    ExamineKey *ek;
    uae_u32 uniq;

    TRACE((warning_buffer, "ACTION_EXAMINE_NEXT(0x%lx,0x%lx)\n", lock, info));
    DUMPLOCK(unit, lock);

    if (lock != 0)
    aino = lookup_aino (unit, get_long(lock + 4));
    if (aino == 0)
    aino = &unit->rootnode;

    uniq = get_long (info);
    if (uniq == 0) {
    write_log ("ExNext called for a file! (Houston?)\n");
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_NO_MORE_ENTRIES);
    return;
    } else if (uniq == 0xFFFFFFFF) {
    ek = new_exkey(unit, aino);
    } else
    ek = lookup_exkey (unit, get_long(info));
    if (ek == 0) {
    write_log ("Couldn't find a matching ExKey. Prepare for trouble.\n");
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_NO_MORE_ENTRIES);
    return;
    }
    put_long(info, ek->uniq);
    do_examine(unit, packet, ek, info);
}

static void do_find (Unit* unit, dpacket packet, int mode, int create, int fallback)
{
 #if 0
    uaecptr fh = GET_PCK_ARG1 (packet) << 2;
    uaecptr lock = GET_PCK_ARG2 (packet) << 2;
    uaecptr name = GET_PCK_ARG3 (packet) << 2;
    struct a_inode *aino;
    Key *k;
    struct stat st;
    int fd;
    int doserr;
    uae_u32 err;
    mode_t openmode;
    int aino_created = 0;

    TRACE((warning_buffer, "ACTION_FIND_*(0x%lx,0x%lx,\"%s\",%d)\n", fh, lock, bstr (unit, name), mode));
    DUMPLOCK(unit, lock);

    aino = find_aino (unit, lock, bstr (unit, name), &err);

    if (aino == 0 || (err != 0 && err != ERROR_OBJECT_NOT_FOUND)) {
    /* Whatever it is, we can't handle it. */
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err);
    return;
    }
    if (err == 0) {
    /* Object exists. */
    if (aino->dir) {
        PUT_PCK_RES1 (packet, DOS_FALSE);
        PUT_PCK_RES2 (packet, ERROR_OBJECT_WRONG_TYPE);
        return;
    }
    if (aino->elock || (create == 2 && aino->shlock > 0)) {
        PUT_PCK_RES1 (packet, DOS_FALSE);
        PUT_PCK_RES2 (packet, ERROR_OBJECT_IN_USE);
        return;
    }
    if (create == 2 && (aino->amigaos_mode & A_FIBF_DELETE) != 0) {
        PUT_PCK_RES1 (packet, DOS_FALSE);
        PUT_PCK_RES2 (packet, ERROR_DELETE_PROTECTED);
        return;
    }
    if (create != 2) {
        if ((((mode & aino->amigaos_mode) & A_FIBF_WRITE) != 0 || unit->ui.readonly)
        && fallback)
        {
        mode &= ~A_FIBF_WRITE;
        }
        /* Kick 1.3 doesn't check read and write access bits - maybe it would be
         * simpler just not to do that either. */
        if ((mode & A_FIBF_WRITE) != 0 && unit->ui.readonly) {
        PUT_PCK_RES1 (packet, DOS_FALSE);
        PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
        return;
        }
        if (((mode & aino->amigaos_mode) & A_FIBF_WRITE) != 0
        || mode == 0)
        {
        PUT_PCK_RES1 (packet, DOS_FALSE);
        PUT_PCK_RES2 (packet, ERROR_WRITE_PROTECTED);
        return;
        }
        if (((mode & aino->amigaos_mode) & A_FIBF_READ) != 0) {
        PUT_PCK_RES1 (packet, DOS_FALSE);
        PUT_PCK_RES2 (packet, ERROR_READ_PROTECTED);
        return;
        }
    }
    } else if (create == 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err);
    return;
    } else {
    aino_created = 1;
    /* Object does not exist. aino points to containing directory. */
    aino = new_child_aino (unit, aino, my_strdup (bstr_cut (unit, name)), 1);
    if (aino == 0) {
        PUT_PCK_RES1 (packet, DOS_FALSE);
        PUT_PCK_RES2 (packet, ERROR_DISK_FULL); /* best we can do */
        return;
    }
    }

    prepare_for_open (aino->nname);

    openmode = (((mode & A_FIBF_READ) == 0 ? O_WRONLY
         : (mode & A_FIBF_WRITE) == 0 ? O_RDONLY
         : O_RDWR)
        | (create ? O_CREAT : 0)
        | (create == 2 ? O_TRUNC : 0));

    fd = open (aino->nname, openmode | O_BINARY, 0777);

    if (fd < 0) {
    if (aino_created)
        delete_aino (unit, aino);
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, dos_errno());
    return;
    }
    k = new_key (unit);
    k->fd = fd;
    k->aino = aino;

    put_long (fh+36, k->uniq);
    if (create == 2)
    aino->elock = 1;
    else
    aino->shlock++;
    de_recycle_aino (unit, aino);
    PUT_PCK_RES1 (packet, DOS_TRUE);
#endif
}

static void
action_find_input(Unit* unit, dpacket packet)
{
    do_find(unit, packet, A_FIBF_READ|A_FIBF_WRITE, 0, 1);
}

static void
action_find_output(Unit* unit, dpacket packet)
{
    if (unit->ui.readonly) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
    return;
    }
    do_find(unit, packet, A_FIBF_READ|A_FIBF_WRITE, 2, 0);
}

static void
action_find_write(Unit* unit, dpacket packet)
{
    if (unit->ui.readonly) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
    return;
    }
    do_find(unit, packet, A_FIBF_READ|A_FIBF_WRITE, 1, 0);
}

static void
action_end(Unit* unit, dpacket packet)
{
    Key *k;
    TRACE((warning_buffer, "ACTION_END(0x%lx)\n", GET_PCK_ARG1 (packet)));

    k = lookup_key (unit, GET_PCK_ARG1 (packet));
    if (k != 0) {
    if (k->aino->elock)
        k->aino->elock = 0;
    else
        k->aino->shlock--;
    recycle_aino (unit, k->aino);
    free_key (unit, k);
    }
    PUT_PCK_RES1 (packet, DOS_TRUE);
    PUT_PCK_RES2 (packet, 0);
}

static void
action_read(Unit* unit, dpacket packet)
{
 #if 0
    Key *k = lookup_key (unit, GET_PCK_ARG1 (packet));
    uaecptr addr = GET_PCK_ARG2 (packet);
    long size = (uae_s32)GET_PCK_ARG3 (packet);
    int actual;

    if (k == 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    /* PUT_PCK_RES2 (packet, EINVAL); */
    return;
    }
    TRACE((warning_buffer, "ACTION_READ(%s,0x%lx,%ld)\n",k->aino->nname,addr,size));
#ifdef RELY_ON_LOADSEG_DETECTION
    /* HACK HACK HACK HACK
     * Try to detect a LoadSeg() */
    if (k->file_pos == 0 && size >= 4) {
    unsigned char buf[4];
    off_t currpos = lseek(k->fd, 0, SEEK_CUR);
    read(k->fd, buf, 4);
    lseek(k->fd, currpos, SEEK_SET);
    if (buf[0] == 0 && buf[1] == 0 && buf[2] == 3 && buf[3] == 0xF3)
        possible_loadseg();
    }
#endif
    if (valid_address (addr, size)) {
    uae_u8 *realpt;
    realpt = get_real_address (addr);
    actual = read(k->fd, realpt, size);

    if (actual == 0) {
        PUT_PCK_RES1 (packet, 0);
        PUT_PCK_RES2 (packet, 0);
    } else if (actual < 0) {
        PUT_PCK_RES1 (packet, 0);
        PUT_PCK_RES2 (packet, dos_errno());
    } else {
        PUT_PCK_RES1 (packet, actual);
        k->file_pos += actual;
    }
    } else {
    char *buf;
    sprintf (warning_buffer, "unixfs warning: Bad pointer passed for read: %08x\n", addr);
    write_log (warning_buffer);
    /* ugh this is inefficient but easy */
    buf = (char *)malloc(size);
    if(!buf) {
        PUT_PCK_RES1 (packet, -1);
        PUT_PCK_RES2 (packet, ERROR_NO_FREE_STORE);
        return;
    }
    actual = read(k->fd, buf, size);

    if (actual < 0) {
        PUT_PCK_RES1 (packet, 0);
        PUT_PCK_RES2 (packet, dos_errno());
    } else {
        int i;
        PUT_PCK_RES1 (packet, actual);
        for(i = 0; i < actual; i++)
        put_byte(addr + i, buf[i]);
        k->file_pos += actual;
    }
    free(buf);
    }
#endif
}

static void
action_write(Unit* unit, dpacket packet)
{
    Key *k = lookup_key (unit, GET_PCK_ARG1 (packet));
    uaecptr addr = GET_PCK_ARG2 (packet);
    long size = GET_PCK_ARG3 (packet);
    char *buf;
    int i;

    if (k == 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    /* PUT_PCK_RES2 (packet, EINVAL); */
    return;
    }

    TRACE((warning_buffer, "ACTION_WRITE(%s,0x%lx,%ld)\n",k->aino->nname,addr,size));

    if(unit->ui.readonly) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
    return;
    }

    /* ugh this is inefficient but easy */
    buf = (char *)malloc(size);
    if(!buf) {
    PUT_PCK_RES1 (packet, -1);
    PUT_PCK_RES2 (packet, ERROR_NO_FREE_STORE);
    return;
    }

    for(i = 0; i < size; i++)
    buf[i] = get_byte(addr + i);

    PUT_PCK_RES1 (packet, write(k->fd, buf, size));
    if (GET_PCK_RES1 (packet) != size)
    PUT_PCK_RES2 (packet, dos_errno());
    if (GET_PCK_RES1 (packet) >= 0)
    k->file_pos += GET_PCK_RES1 (packet);

    free(buf);
}

static void
action_seek(Unit* unit, dpacket packet)
{
    Key* k = lookup_key (unit, GET_PCK_ARG1 (packet));
    long pos = (uae_s32)GET_PCK_ARG2 (packet);
    long mode = (uae_s32)GET_PCK_ARG3 (packet);
    off_t res;
    long old;
    int whence = SEEK_CUR;

    if (k == 0) {
    PUT_PCK_RES1 (packet, -1);
    PUT_PCK_RES2 (packet, ERROR_INVALID_LOCK);
    return;
    }

    if(mode > 0) whence = SEEK_END;
    if(mode < 0) whence = SEEK_SET;

    TRACE((warning_buffer, "ACTION_SEEK(%s,%d,%d)\n",k->aino->nname,pos,mode));

    old = lseek(k->fd, 0, SEEK_CUR);
    res = lseek(k->fd, pos, whence);

    if(-1 == res) {
    PUT_PCK_RES1 (packet, res);
    PUT_PCK_RES2 (packet, ERROR_SEEK_ERROR);
    } else
    PUT_PCK_RES1 (packet, old);
    k->file_pos = res;
}

static void
action_set_protect(Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG2 (packet) << 2;
    uaecptr name = GET_PCK_ARG3 (packet) << 2;
    uae_u32 mask = GET_PCK_ARG4 (packet);
    mode_t mode;
    struct a_inode *a;
    uae_u32 err;

    TRACE((warning_buffer, "ACTION_SET_PROTECT(0x%lx,\"%s\",0x%lx)\n", lock, bstr (unit, name), mask));

    if(unit->ui.readonly) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
    return;
    }

    a = find_aino (unit, lock, bstr (unit, name), &err);
    if (err != 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err);
    return;
    }

    err = set_file_attrs (a, mask);
    if (err != 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err);
    } else {
    PUT_PCK_RES1 (packet, DOS_TRUE);
    }
}

static void
action_same_lock(Unit* unit, dpacket packet)
{
    uaecptr lock1 = GET_PCK_ARG1 (packet) << 2;
    uaecptr lock2 = GET_PCK_ARG2 (packet) << 2;

    TRACE((warning_buffer, "ACTION_SAME_LOCK(0x%lx,0x%lx)\n",lock1,lock2));
    DUMPLOCK(unit, lock1); DUMPLOCK(unit, lock2);

    if(!lock1 || !lock2) {
    PUT_PCK_RES1 (packet, lock1 == lock2 ? DOS_TRUE : DOS_FALSE);
    } else {
    PUT_PCK_RES1 (packet, get_long (lock1 + 4) == get_long (lock2 + 4) ? DOS_TRUE : DOS_FALSE);
    }
}

static void
action_parent(Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG1 (packet) << 2;
    struct a_inode *a, *olda;

    TRACE((warning_buffer, "ACTION_PARENT(0x%lx)\n",lock));

    if (!lock) {
    PUT_PCK_RES1 (packet, 0);
    PUT_PCK_RES2 (packet, 0);
    return;
    }

    olda = lookup_aino (unit, get_long(lock + 4));
    if (olda == 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_INVALID_LOCK);
    return;
    }

    if (olda->parent == 0) {
    PUT_PCK_RES1 (packet, 0);
    PUT_PCK_RES2 (packet, 0);
    return;
    }
    if (olda->parent->elock) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_OBJECT_IN_USE);
    return;
    }
    olda->parent->shlock++;
    de_recycle_aino (unit, olda->parent);
    PUT_PCK_RES1 (packet, make_lock (unit, olda->parent->uniq, -2) >> 2);
}

static void
action_create_dir(Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG1 (packet) << 2;
    uaecptr name = GET_PCK_ARG2 (packet) << 2;
    struct a_inode *aino;
    uae_u32 err;

    TRACE((warning_buffer, "ACTION_CREATE_DIR(0x%lx,\"%s\")\n", lock, bstr (unit, name)));

    if(unit->ui.readonly) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
    return;
    }

    aino = find_aino (unit, lock, bstr (unit, name), &err);
    if (aino == 0 || (err != 0 && err != ERROR_OBJECT_NOT_FOUND)) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err);
    return;
    }
    if (err == 0) {
    /* Object exists. */
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_OBJECT_EXISTS);
    return;
    }
    /* Object does not exist. aino points to containing directory. */
    aino = new_child_aino (unit, aino, my_strdup (bstr_cut (unit, name)), 2);
    if (aino == 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_FULL); /* best we can do */
    return;
    }

    if (mkdir (aino->nname, 0777) == -1) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, dos_errno());
    return;
    }
    aino->shlock = 1;
    de_recycle_aino (unit, aino);
    PUT_PCK_RES1 (packet, make_lock (unit, aino->uniq, -2) >> 2);
}

static void
action_delete_object(Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG1 (packet) << 2;
    uaecptr name = GET_PCK_ARG2 (packet) << 2;
    struct a_inode *a;
    uae_u32 err;

    TRACE((warning_buffer, "ACTION_DELETE_OBJECT(0x%lx,\"%s\")\n", lock, bstr (unit, name)));

    if (unit->ui.readonly) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
    return;
    }

    a = find_aino (unit, lock, bstr (unit, name), &err);

    if (err != 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err);
    return;
    }
    if (a->shlock > 0 || a->elock) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_OBJECT_IN_USE);
    return;
    }
    if (a->dir) {
    if (rmdir (a->nname) == -1) {
        PUT_PCK_RES1 (packet, DOS_FALSE);
        PUT_PCK_RES2 (packet, dos_errno());
        return;
    }
    } else {
    if (unlink (a->nname) == -1) {
        PUT_PCK_RES1 (packet, DOS_FALSE);
        PUT_PCK_RES2 (packet, dos_errno());
        return;
    }
    }
    if (a->child != 0) {
    write_log ("Serious error in action_delete_object.\n");
    } else {
    delete_aino (unit, a);
    }
    PUT_PCK_RES1 (packet, DOS_TRUE);
}

static void
action_set_date(Unit* unit, dpacket packet)
{
    uaecptr lock = GET_PCK_ARG2 (packet) << 2;
    uaecptr name = GET_PCK_ARG3 (packet) << 2;
    uaecptr date = GET_PCK_ARG4 (packet);
    struct a_inode *a;
    struct utimbuf ut;
    uae_u32 err;

    TRACE((warning_buffer, "ACTION_SET_DATE(0x%lx,\"%s\")\n", lock, bstr (unit, name)));

    if(unit->ui.readonly) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
    return;
    }

    ut.actime = ut.modtime = put_time(get_long(date),get_long(date+4),get_long(date+8));
    a = find_aino (unit, lock, bstr (unit, name), &err);
    if (err == 0 && utime (a->nname, &ut) == -1)
    err = dos_errno ();
    if (err != 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err);
    } else
    PUT_PCK_RES1 (packet, DOS_TRUE);
}

static void
action_rename_object(Unit* unit, dpacket packet)
{
    uaecptr lock1 = GET_PCK_ARG1 (packet) << 2;
    uaecptr name1 = GET_PCK_ARG2 (packet) << 2;
    uaecptr lock2 = GET_PCK_ARG3 (packet) << 2;
    uaecptr name2 = GET_PCK_ARG4 (packet) << 2;
    struct a_inode *a1, *a2;
    uae_u32 err1, err2;

    TRACE((warning_buffer, "ACTION_RENAME_OBJECT(0x%lx,\"%s\",", lock1, bstr (unit, name1)));
    TRACE((warning_buffer, "0x%lx,\"%s\")\n", lock2, bstr (unit, name2)));

    if(unit->ui.readonly) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
    return;
    }

    a1 = find_aino (unit, lock1, bstr (unit, name1), &err1);
    if (err1 != 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err1);
    return;
    }
    a2 = find_aino (unit, lock2, bstr (unit, name2), &err2);
    if (a2 == 0 || err2 != ERROR_OBJECT_NOT_FOUND) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, err2 == 0 ? ERROR_OBJECT_EXISTS : err2);
    return;
    }
    /* Object does not exist. aino points to containing directory. */
    a2 = new_child_aino (unit, a2, my_strdup (bstr_cut (unit, name2)), a1->dir ? 2 : 1);
    if (a2 == 0) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_FULL); /* best we can do */
    return;
    }

    /* @@@ what should we do if there are locks on a1? */
    if(-1 == rename(a1->nname, a2->nname)) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, dos_errno());
    return;
    }
    move_aino_children (unit, a1, a2);
    delete_aino (unit, a1);
    PUT_PCK_RES1 (packet, DOS_TRUE);
}

static void
action_current_volume(Unit* unit, dpacket packet)
{
    PUT_PCK_RES1 (packet, unit->volume >> 2);
}

static void
action_rename_disk(Unit* unit, dpacket packet)
{
    uaecptr name = GET_PCK_ARG1 (packet) << 2;
    int i;
    int namelen;

    TRACE((warning_buffer, "ACTION_RENAME_DISK(\"%s\")\n", bstr (unit, name)));

    if(unit->ui.readonly) {
    PUT_PCK_RES1 (packet, DOS_FALSE);
    PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
    return;
    }

    /* get volume name */
    namelen = get_byte (name); name++;
    free (unit->ui.volname);
    unit->ui.volname = (char *) malloc (namelen + 1);
    for(i = 0; i < namelen; i++, name++)
    unit->ui.volname[i] = get_byte (name);
    unit->ui.volname[i] = 0;

    put_byte (unit->volume + 44, namelen);
    for(i = 0; i < namelen; i++)
    put_byte (unit->volume + 45 + i, unit->ui.volname[i]);

    PUT_PCK_RES1 (packet, DOS_TRUE);
}

static void
action_is_filesystem(Unit* unit, dpacket packet)
{
    PUT_PCK_RES1 (packet, DOS_TRUE);
}

static void
action_flush(Unit* unit, dpacket packet)
{
    /* sync(); */ /* pretty drastic, eh */
    PUT_PCK_RES1 (packet, DOS_TRUE);
}

/* We don't want multiple interrupts to be active at the same time. I don't
 * know whether AmigaOS takes care of that, but this does. */
static uae_sem_t singlethread_int_sem;

static uae_u32 exter_int_helper (void)
{
    static int unit_no;

    switch (m68k_dreg (regs, 0)) {
     case 0:
    /* Determine whether a given EXTER interrupt is for us. */
    if (uae_int_requested) {
        if (uae_sem_trywait (&singlethread_int_sem) != 0)
        /* Pretend it isn't for us. We might get it again later. */
        return 0;
        /* Clear the interrupt flag _before_ we do any processing.
         * That way, we can get too many interrupts, but never not
         * enough. */
        uae_int_requested = 0;
        unit_no = 0;
        return 1;
    }
    return 0;
     case 1:
    /* Release a message_lock. This is called as soon as the message is
     * received by the assembly code. We use the opportunity to check
     * whether we have some locks that we can give back to the assembler
     * code.
     * Note that this is called from the main loop, unlike the other cases
     * in this switch statement which are called from the interrupt handler.
     */
    {
        Unit *unit = find_unit (m68k_areg (regs, 5));
        unit->cmds_complete = unit->cmds_acked;
        while (comm_pipe_has_data (unit->ui.back_pipe)) {
        uaecptr locks, lockend;
        locks = read_comm_pipe_int_blocking (unit->ui.back_pipe);
        lockend = locks;
        while (get_long (lockend) != 0)
            lockend = get_long (lockend);
        put_long (lockend, get_long (m68k_areg (regs, 3)));
        put_long (m68k_areg (regs, 3), locks);
        }
    }
    break;
     case 2:
    /* Find some unit that needs a message sent, and return its port,
     * or zero if all are done.
     * Take care not to dereference self for units that didn't have their
     * startup packet sent. */
    for (;;) {
        if (unit_no >= num_units)
        return 0;
        if (ui[unit_no].self != 0
        && ui[unit_no].self->cmds_acked == ui[unit_no].self->cmds_complete
        && ui[unit_no].self->cmds_acked != ui[unit_no].self->cmds_sent)
        break;
        unit_no++;
    }
    ui[unit_no].self->cmds_acked = ui[unit_no].self->cmds_sent;
    return ui[unit_no++].self->port;

     case 3:
    /* Look up a message for a port. */
    {
        Unit *unit = find_unit (m68k_areg (regs, 2));
        return unit->dummy_message;
    }
    break;
     case 4:
    /* Exit the interrupt, and release the single-threading lock. */
    uae_sem_post (&singlethread_int_sem);
    break;

     default:
    write_log ("Shouldn't happen in exter_int_helper.\n");
    break;
    }
    return 0;
}

static int handle_packet (Unit *unit, dpacket pck)
{
    uae_s32 type = GET_PCK_TYPE (pck);
    PUT_PCK_RES2 (pck, 0);
    switch (type) {
     case ACTION_LOCATE_OBJECT: action_lock(unit, pck); break;
     case ACTION_FREE_LOCK: action_free_lock(unit, pck); break;
     case ACTION_COPY_DIR: action_dup_lock(unit, pck); break;
     case ACTION_DISK_INFO: action_disk_info(unit, pck); break;
     case ACTION_INFO: action_info(unit, pck); break;
     case ACTION_EXAMINE_OBJECT: action_examine_object(unit, pck); break;
     case ACTION_EXAMINE_NEXT: action_examine_next(unit, pck); break;
     case ACTION_FIND_INPUT: action_find_input(unit, pck); break;
     case ACTION_FIND_WRITE: action_find_write(unit, pck); break;
     case ACTION_FIND_OUTPUT: action_find_output(unit, pck); break;
     case ACTION_END: action_end(unit, pck); break;
     case ACTION_READ: action_read(unit, pck); break;
     case ACTION_WRITE: action_write(unit, pck); break;
     case ACTION_SEEK: action_seek(unit, pck); break;
     case ACTION_SET_PROTECT: action_set_protect(unit, pck); break;
     case ACTION_SAME_LOCK: action_same_lock(unit, pck); break;
     case ACTION_PARENT: action_parent(unit, pck); break;
     case ACTION_CREATE_DIR: action_create_dir(unit, pck); break;
     case ACTION_DELETE_OBJECT: action_delete_object(unit, pck); break;
     case ACTION_RENAME_OBJECT: action_rename_object(unit, pck); break;
     case ACTION_SET_DATE: action_set_date(unit, pck); break;
     case ACTION_CURRENT_VOLUME: action_current_volume(unit, pck); break;
     case ACTION_RENAME_DISK: action_rename_disk(unit, pck); break;
     case ACTION_IS_FILESYSTEM: action_is_filesystem(unit, pck); break;
     case ACTION_FLUSH: action_flush(unit, pck); break;
     default:
    TRACE((warning_buffer, "*** UNSUPPORTED PACKET %ld\n", type));
    return 0;
    }
    return 1;
}

#ifdef SUPPORT_THREADS
static void *filesys_penguin (void *unit_v)
{
    UnitInfo *ui = (UnitInfo *)unit_v;
    for (;;) {
    uae_u8 *pck;
    uae_u8 *msg;
    uae_u32 morelocks;
    int i;

    pck = (uae_u8 *)read_comm_pipe_pvoid_blocking (ui->unit_pipe);
    msg = (uae_u8 *)read_comm_pipe_pvoid_blocking (ui->unit_pipe);
    morelocks = (uae_u32)read_comm_pipe_int_blocking (ui->unit_pipe);

    if (ui->self->reset_state == FS_GO_DOWN) {
        if (pck != 0)
        continue;
        /* Death message received. */
        uae_sem_post (&ui->self->reset_sync_sem);
        /* No more messages should arrive until we restart. */
        continue;
    }

    put_long (get_long (morelocks), get_long (ui->self->locklist));
    put_long (ui->self->locklist, morelocks);
    if (! handle_packet (ui->self, pck)) {
        PUT_PCK_RES1 (pck, DOS_FALSE);
        PUT_PCK_RES2 (pck, ERROR_ACTION_NOT_KNOWN);
    }
    /* Mark the packet as processed for the list scan in the assembly code. */
    do_put_mem_long ((uae_u32 *)(msg + 4), -1);
    /* Acquire the message lock, so that we know we can safely send the
     * message. */
    ui->self->cmds_sent++;
    /* The message is sent by our interrupt handler, so make sure an interrupt
     * happens. */
    uae_int_requested = 1;
    /* Send back the locks. */
    if (get_long (ui->self->locklist) != 0)
        write_comm_pipe_int (ui->back_pipe, (int)(get_long(ui->self->locklist)), 0);
    put_long (ui->self->locklist, 0);
    }
    return 0;
}
#endif

/* Talk about spaghetti code... */
static uae_u32 filesys_handler(void)
{
    Unit *unit = find_unit (m68k_areg (regs, 5));
    uaecptr packet_addr = m68k_dreg (regs, 3);
    uaecptr message_addr = m68k_areg (regs, 4);
    uae_u8 *pck;
    uae_u8 *msg;
    if (! valid_address (packet_addr, 36) || ! valid_address (message_addr, 14)) {
    write_log ("Bad address passed for packet.\n");
    goto error2;
    }
    pck = get_real_address (packet_addr);
    msg = get_real_address (message_addr);

    if (unit->reset_state == FS_GO_DOWN)
    /* You might as well queue it, if you live long enough */
    return 1;

    do_put_mem_long ((uae_u32 *)(msg + 4), -1);
    if (!unit || !unit->volume) {
    write_log ("Filesystem was not initialized.\n");
    goto error;
    }
#ifdef SUPPORT_THREADS
    {
    /* Get two more locks and hand them over to the other thread. */
    uae_u32 morelocks;
    morelocks = get_long (m68k_areg (regs, 3));
    put_long (m68k_areg (regs, 3), get_long (get_long (morelocks)));
    put_long (get_long (morelocks), 0);

    /* The packet wasn't processed yet. */
    do_put_mem_long ((uae_u32 *)(msg + 4), 0);
    write_comm_pipe_pvoid (unit->ui.unit_pipe, (void *)pck, 0);
    write_comm_pipe_pvoid (unit->ui.unit_pipe, (void *)msg, 0);
    write_comm_pipe_int (unit->ui.unit_pipe, (int)morelocks, 1);
    /* Don't reply yet. */
    return 1;
    }
#endif

    if (! handle_packet (unit, pck)) {
     error:
    PUT_PCK_RES1 (pck, DOS_FALSE);
    PUT_PCK_RES2 (pck, ERROR_ACTION_NOT_KNOWN);
    }
    TRACE((warning_buffer, "reply: %8lx, %ld\n", GET_PCK_RES1 (pck), GET_PCK_RES2 (pck)));

    error2:

    return 0;
}

void filesys_reset (void)
{
    Unit *u, *u1;
    int i;

    for (i = 0; i < num_units; i++) {
    ui[i].self = 0;
    }

    for(u = units; u; u = u1) {
    u1 = u->next;
    free (u);
    }
    unit_num = 0;
    units = 0;
}

void filesys_prepare_reset (void)
{
    Unit *u, *u1;
    int i;

#ifdef SUPPORT_THREADS
    for (i = 0; i < num_units; i++) {
    if (ui[i].self != 0) {
        uae_sem_init (&ui[i].self->reset_sync_sem, 0, 0);
        ui[i].self->reset_state = FS_GO_DOWN;
        /* send death message */
        write_comm_pipe_int (ui[i].unit_pipe, 0, 0);
        write_comm_pipe_int (ui[i].unit_pipe, 0, 0);
        write_comm_pipe_int (ui[i].unit_pipe, 0, 1);
        uae_sem_wait (&ui[i].self->reset_sync_sem);
    }
    }
#endif
    u = units;
    while (u != 0) {
    while (u->rootnode.next != &u->rootnode) {
        struct a_inode *a = u->rootnode.next;
        u->rootnode.next = a->next;
        free (a->nname);
        free (a->aname);
        free (a);
    }
    u = u->next;
    }
}

static uae_u32 filesys_diagentry(void)
{
    uaecptr resaddr = m68k_areg(regs, 2) + 0x10;

    filesys_configdev = m68k_areg(regs, 3);

    filesys_store_devinfo (filesysory + 0x2100);
    uae_sem_init (&singlethread_int_sem, 0, 1);
    if (ROM_hardfile_resid != 0) {
    /* Build a struct Resident. This will set up and initialize
     * the uae.device */
    put_word(resaddr + 0x0, 0x4AFC);
    put_long(resaddr + 0x2, resaddr);
    put_long(resaddr + 0x6, resaddr + 0x1A); /* Continue scan here */
    put_word(resaddr + 0xA, 0x8101); /* RTF_AUTOINIT|RTF_COLDSTART; Version 1 */
    put_word(resaddr + 0xC, 0x0305); /* NT_DEVICE; pri 05 */
    put_long(resaddr + 0xE, ROM_hardfile_resname);
    put_long(resaddr + 0x12, ROM_hardfile_resid);
    put_long(resaddr + 0x16, ROM_hardfile_init); /* calls filesys_init */
    }
    resaddr += 0x1A;

    filesys_reset ();
    /* The good thing about this function is that it always gets called
     * when we boot. So we could put all sorts of stuff that wants to be done
     * here. */

    return 1;
}

static uae_u32 filesys_dev_remember(void)
{
    /* In: a3: devicenode, d6: unit_no */

    ui[m68k_dreg (regs, 6)].startup = get_long(m68k_areg (regs, 3) + 28);
    return m68k_areg (regs, 3);
}

/* Called exactly once, at the time we know that we are actually going
 * to run the emulator. */
void filesys_start_threads (void)
{
    int i;
    for (i = 0; i < num_units; i++) {
    int is_hardfile = ui[i].volname == 0;
    ui[i].unit_pipe = 0;
#ifdef SUPPORT_THREADS
    if (!is_hardfile) {
        ui[i].unit_pipe = (smp_comm_pipe *)malloc (sizeof (smp_comm_pipe));
        ui[i].back_pipe = (smp_comm_pipe *)malloc (sizeof (smp_comm_pipe));
        init_comm_pipe (ui[i].unit_pipe, 50, 3);
        init_comm_pipe (ui[i].back_pipe, 50, 1);
        start_penguin (filesys_penguin, (void *)(ui + i), &ui[i].tid);
    }
#endif
    }
}

void filesys_install (void)
{
    int i;
    uaecptr loop;

    ROM_filesys_resname = ds("UAEunixfs.resource");
    ROM_filesys_resid = ds("UAE unixfs 0.4");

    fsdevname = ds("uae.device"); /* does not really exist */

    for(i = 0; i < num_units; i++) {
    ui[i].devno = get_new_device(&ui[i].devname, &ui[i].devname_amiga);
    }

    ROM_filesys_diagentry = here();
    calltrap (deftrap(filesys_diagentry)); dw(RTS);

    loop = here ();
    /* Special trap for the assembly make_dev routine */
    org(0xF0FF20);
    calltrap (deftrap (filesys_dev_remember));
    dw(RTS);

    org(0xF0FF30);
    calltrap (deftrap (filesys_handler));
    dw(RTS);

    org(0xF0FF40);
    calltrap (deftrap (startup_handler));
    dw(RTS);

    org(0xF0FF50);
    calltrap (deftrap (exter_int_helper));
    dw(RTS);

    org(0xF0FF70);
    calltrap (deftrap (mousehack_helper));
    dw(RTS);

    org (loop);
}

void filesys_install_code (void)
{
    align(4);

    /* The last offset comes from the code itself, look for it near the top. */
    filesys_initcode = here() + 8 + 0x6c;
    EXPANSION_bootcode = here () + 8 + 0x14;
    /* Ouch. Make sure this is _always_ a multiple of two bytes. */
 db(0x00); db(0x00); db(0x00); db(0x10); db(0x00); db(0x00); db(0x00); db(0x00);
 db(0x60); db(0x00); db(0x01); db(0xda); db(0x00); db(0x00); db(0x01); db(0x2c);
 db(0x00); db(0x00); db(0x00); db(0x6c); db(0x00); db(0x00); db(0x00); db(0x28);
 db(0x00); db(0x00); db(0x00); db(0x14); db(0x43); db(0xfa); db(0x03); db(0x13);
 db(0x4e); db(0xae); db(0xff); db(0xa0); db(0x20); db(0x40); db(0x20); db(0x28);
 db(0x00); db(0x16); db(0x20); db(0x40); db(0x4e); db(0x90); db(0x4e); db(0x75);
 db(0x48); db(0xe7); db(0x00); db(0x20); db(0x70); db(0x00); db(0x4e); db(0xb9);
 db(0x00); db(0xf0); db(0xff); db(0x50); db(0x4a); db(0x80); db(0x67); db(0x2e);
 db(0x2c); db(0x78); db(0x00); db(0x04); db(0x70); db(0x02); db(0x4e); db(0xb9);
 db(0x00); db(0xf0); db(0xff); db(0x50); db(0x4a); db(0x80); db(0x67); db(0x14);
 db(0x24); db(0x40); db(0x70); db(0x03); db(0x4e); db(0xb9); db(0x00); db(0xf0);
 db(0xff); db(0x50); db(0x20); db(0x4a); db(0x22); db(0x40); db(0x4e); db(0xae);
 db(0xfe); db(0x92); db(0x60); db(0xe0); db(0x70); db(0x04); db(0x4e); db(0xb9);
 db(0x00); db(0xf0); db(0xff); db(0x50); db(0x70); db(0x01); db(0x4c); db(0xdf);
 db(0x04); db(0x00); db(0x4e); db(0x75); db(0x48); db(0xe7); db(0xff); db(0xfe);
 db(0x2c); db(0x78); db(0x00); db(0x04); db(0x2a); db(0x79); db(0x00); db(0xf0);
 db(0xff); db(0xfc); db(0x43); db(0xfa); db(0x02); db(0xb9); db(0x70); db(0x24);
 db(0x7a); db(0x00); db(0x4e); db(0xae); db(0xfd); db(0xd8); db(0x4a); db(0x80);
 db(0x66); db(0x0c); db(0x43); db(0xfa); db(0x02); db(0xa9); db(0x70); db(0x00);
 db(0x7a); db(0x01); db(0x4e); db(0xae); db(0xfd); db(0xd8); db(0x28); db(0x40);
 db(0x70); db(0x58); db(0x72); db(0x01); db(0x4e); db(0xae); db(0xff); db(0x3a);
 db(0x26); db(0x40); db(0x7e); db(0x54); db(0x27); db(0xb5); db(0x78); db(0x00);
 db(0x78); db(0x00); db(0x59); db(0x87); db(0x64); db(0xf6); db(0x7c); db(0x00);
 db(0xbc); db(0xad); db(0x01); db(0x0c); db(0x64); db(0x12); db(0x20); db(0x4b);
 db(0x48); db(0xe7); db(0x02); db(0x10); db(0x7e); db(0x01); db(0x61); db(0x6c);
 db(0x4c); db(0xdf); db(0x08); db(0x40); db(0x52); db(0x86); db(0x60); db(0xe8);
 db(0x2c); db(0x78); db(0x00); db(0x04); db(0x22); db(0x4c); db(0x4e); db(0xae);
 db(0xfe); db(0x62); db(0x61); db(0x28); db(0x2c); db(0x78); db(0x00); db(0x04);
 db(0x4e); db(0xb9); db(0x00); db(0xf0); db(0xff); db(0x80); db(0x72); db(0x03);
 db(0x74); db(0xf6); db(0x20); db(0x7c); db(0x00); db(0x20); db(0x00); db(0x00);
 db(0x90); db(0x88); db(0x65); db(0x0a); db(0x67); db(0x08); db(0x78); db(0x00);
 db(0x22); db(0x44); db(0x4e); db(0xae); db(0xfd); db(0x96); db(0x4c); db(0xdf);
 db(0x7f); db(0xff); db(0x4e); db(0x75); db(0x2c); db(0x78); db(0x00); db(0x04);
 db(0x70); db(0x1a); db(0x22); db(0x3c); db(0x00); db(0x01); db(0x00); db(0x01);
 db(0x4e); db(0xae); db(0xff); db(0x3a); db(0x22); db(0x40); db(0x41); db(0xfa);
 db(0x02); db(0x0a); db(0x23); db(0x48); db(0x00); db(0x0a); db(0x41); db(0xfa);
 db(0xff); db(0x10); db(0x23); db(0x48); db(0x00); db(0x0e); db(0x41); db(0xfa);
 db(0xff); db(0x08); db(0x23); db(0x48); db(0x00); db(0x12); db(0x70); db(0x0d);
 db(0x4e); db(0xee); db(0xff); db(0x58); db(0x2a); db(0x79); db(0x00); db(0xf0);
 db(0xff); db(0xfc); db(0x26); db(0x06); db(0xe9); db(0x8b); db(0xd6); db(0xbc);
 db(0x00); db(0x00); db(0x01); db(0x10); db(0x20); db(0x35); db(0x38); db(0x0c);
 db(0xc0); db(0x85); db(0x66); db(0xb6); db(0x20); db(0xb5); db(0x38); db(0x00);
 db(0x21); db(0x75); db(0x38); db(0x04); db(0x00); db(0x04); db(0x21); db(0x75);
 db(0x38); db(0x08); db(0x00); db(0x08); db(0x2c); db(0x4c); db(0x4e); db(0xae);
 db(0xff); db(0x70); db(0x26); db(0x40); db(0x4e); db(0xb9); db(0x00); db(0xf0);
 db(0xff); db(0x20); db(0x70); db(0x00); db(0x27); db(0x40); db(0x00); db(0x08);
 db(0x27); db(0x40); db(0x00); db(0x10); db(0x27); db(0x40); db(0x00); db(0x20);
 db(0x20); db(0x35); db(0x38); db(0x0c); db(0x4a); db(0x80); db(0x66); db(0x1c);
 db(0x27); db(0x7c); db(0x00); db(0x00); db(0x0f); db(0xa0); db(0x00); db(0x14);
 db(0x43); db(0xfa); db(0xfe); db(0x7a); db(0x20); db(0x09); db(0xe4); db(0x88);
 db(0x27); db(0x40); db(0x00); db(0x20); db(0x27); db(0x7c); db(0xff); db(0xff);
 db(0xff); db(0xff); db(0x00); db(0x24); db(0x4a); db(0x87); db(0x67); db(0x36);
 db(0x2c); db(0x78); db(0x00); db(0x04); db(0x70); db(0x14); db(0x72); db(0x00);
 db(0x4e); db(0xae); db(0xff); db(0x3a); db(0x22); db(0x40); db(0x70); db(0x00);
 db(0x22); db(0x80); db(0x23); db(0x40); db(0x00); db(0x04); db(0x33); db(0x40);
 db(0x00); db(0x0e); db(0x30); db(0x3c); db(0x10); db(0xff); db(0x90); db(0x06);
 db(0x33); db(0x40); db(0x00); db(0x08); db(0x23); db(0x6d); db(0x01); db(0x04);
 db(0x00); db(0x0a); db(0x23); db(0x4b); db(0x00); db(0x10); db(0x41); db(0xec);
 db(0x00); db(0x4a); db(0x4e); db(0xee); db(0xfe); db(0xf2); db(0x20); db(0x4b);
 db(0x72); db(0x00); db(0x22); db(0x41); db(0x70); db(0xff); db(0x2c); db(0x4c);
 db(0x4e); db(0xee); db(0xff); db(0x6a); db(0x2c); db(0x78); db(0x00); db(0x04);
 db(0x70); db(0x00); db(0x22); db(0x40); db(0x4e); db(0xae); db(0xfe); db(0xda);
 db(0x20); db(0x40); db(0x4b); db(0xe8); db(0x00); db(0x5c); db(0x43); db(0xfa);
 db(0x01); db(0x39); db(0x70); db(0x00); db(0x4e); db(0xae); db(0xfd); db(0xd8);
 db(0x24); db(0x40); db(0x20); db(0x3c); db(0x00); db(0x00); db(0x00); db(0x9d);
 db(0x22); db(0x3c); db(0x00); db(0x01); db(0x00); db(0x01); db(0x4e); db(0xae);
 db(0xff); db(0x3a); db(0x26); db(0x40); db(0x7c); db(0x00); db(0x26); db(0x86);
 db(0x27); db(0x46); db(0x00); db(0x04); db(0x27); db(0x46); db(0x00); db(0x08);
 db(0x7a); db(0x00); db(0x20); db(0x4d); db(0x4e); db(0xae); db(0xfe); db(0x80);
 db(0x20); db(0x4d); db(0x4e); db(0xae); db(0xfe); db(0x8c); db(0x28); db(0x40);
 db(0x26); db(0x2c); db(0x00); db(0x0a); db(0x70); db(0x00); db(0x4e); db(0xb9);
 db(0x00); db(0xf0); db(0xff); db(0x40); db(0x60); db(0x74); db(0x20); db(0x4d);
 db(0x4e); db(0xae); db(0xfe); db(0x80); db(0x20); db(0x4d); db(0x4e); db(0xae);
 db(0xfe); db(0x8c); db(0x28); db(0x40); db(0x26); db(0x2c); db(0x00); db(0x0a);
 db(0x66); db(0x38); db(0x70); db(0x01); db(0x4e); db(0xb9); db(0x00); db(0xf0);
 db(0xff); db(0x50); db(0x45); db(0xeb); db(0x00); db(0x04); db(0x20); db(0x52);
 db(0x20); db(0x08); db(0x67); db(0xda); db(0x22); db(0x50); db(0x20); db(0x40);
 db(0x20); db(0x28); db(0x00); db(0x04); db(0x6a); db(0x16); db(0x48); db(0xe7);
 db(0x00); db(0xc0); db(0x28); db(0x68); db(0x00); db(0x0a); db(0x61); db(0x40);
 db(0x53); db(0x85); db(0x4c); db(0xdf); db(0x03); db(0x00); db(0x24); db(0x89);
 db(0x20); db(0x49); db(0x60); db(0xdc); db(0x24); db(0x48); db(0x20); db(0x49);
 db(0x60); db(0xd6); db(0xba); db(0xbc); db(0x00); db(0x00); db(0x00); db(0x14);
 db(0x65); db(0x08); db(0x70); db(0x01); db(0x29); db(0x40); db(0x00); db(0x04);
 db(0x60); db(0x0e); db(0x61); db(0x2a); db(0x4e); db(0xb9); db(0x00); db(0xf0);
 db(0xff); db(0x30); db(0x4a); db(0x80); db(0x67); db(0x0c); db(0x52); db(0x85);
 db(0x28); db(0xab); db(0x00); db(0x04); db(0x27); db(0x4c); db(0x00); db(0x04);
 db(0x60); db(0x8c); db(0x28); db(0x43); db(0x61); db(0x02); db(0x60); db(0x86);
 db(0x22); db(0x54); db(0x20); db(0x6c); db(0x00); db(0x04); db(0x29); db(0x4d);
 db(0x00); db(0x04); db(0x4e); db(0xee); db(0xfe); db(0x92); db(0x2f); db(0x05);
 db(0x7a); db(0xfc); db(0x24); db(0x53); db(0x2e); db(0x0a); db(0x22); db(0x0a);
 db(0x67); db(0x0a); db(0x52); db(0x85); db(0x67); db(0x1e); db(0x22); db(0x4a);
 db(0x24); db(0x52); db(0x60); db(0xf2); db(0x52); db(0x85); db(0x67); db(0x3c);
 db(0x24); db(0x47); db(0x70); db(0x18); db(0x72); db(0x01); db(0x4e); db(0xae);
 db(0xff); db(0x3a); db(0x52); db(0x46); db(0x24); db(0x40); db(0x24); db(0x87);
 db(0x2e); db(0x0a); db(0x60); db(0xe8); db(0x20); db(0x12); db(0x67); db(0x24);
 db(0x20); db(0x40); db(0x20); db(0x10); db(0x67); db(0x1e); db(0x20); db(0x40);
 db(0x20); db(0x10); db(0x67); db(0x18); db(0x70); db(0x00); db(0x22); db(0x80);
 db(0x22); db(0x4a); db(0x24); db(0x51); db(0x70); db(0x18); db(0x4e); db(0xae);
 db(0xff); db(0x2e); db(0xdc); db(0xbc); db(0x00); db(0x01); db(0x00); db(0x00);
 db(0x20); db(0x0a); db(0x66); db(0xec); db(0x26); db(0x87); db(0x2a); db(0x1f);
 db(0x4e); db(0x75); db(0x55); db(0x41); db(0x45); db(0x20); db(0x66); db(0x69);
 db(0x6c); db(0x65); db(0x73); db(0x79); db(0x73); db(0x74); db(0x65); db(0x6d);
 db(0x00); db(0x64); db(0x6f); db(0x73); db(0x2e); db(0x6c); db(0x69); db(0x62);
 db(0x72); db(0x61); db(0x72); db(0x79); db(0x00); db(0x65); db(0x78); db(0x70);
 db(0x61); db(0x6e); db(0x73); db(0x69); db(0x6f); db(0x6e); db(0x2e); db(0x6c);
 db(0x69); db(0x62); db(0x72); db(0x61); db(0x72); db(0x79); db(0x00); db(0x00);
}

#endif